package Negocios;

import java.util.ArrayList;
import java.util.List;

import DTO.DTOFecha;
import DTO.DTOGestionarResultado;
import DTO.DTOMostrarFixture;
import DTO.DTOProximosEncuentros;
import DTO.DTOPuntuacion;
import DTO.DTOResultadoFinal;
import DTO.DTOSet;
import DTO.DTOSets;
import DTO.DTOUnResultado;
import DTO.DTOTablaDePosiciones;
import DTO.DTOFixture;
import Excepcion.CompetenciaNoPermiteEmpateException;
import Excepcion.EmpateEnEliminacionException;
import Excepcion.EmpateSetException;
import Excepcion.EspaciosVaciosException;
import Excepcion.FaltanPartidosAnterioresException;
import Excepcion.FixtureDisputaFinalizadoException;
import Excepcion.NoHayDisponibilidadException;
import Excepcion.PuntajeNegativoException;
import Excepcion.PuntajeOverflowException;
import Excepcion.ResultadoNoModificableException;
import Excepcion.TablaNoPermitidaException;
import Persistencia.DAO.DAOCompetencia;
import Persistencia.DAO.DAOPartido;
import Persistencia.Entidad.Competencia;
import Persistencia.Entidad.Disponibilidad;
import Persistencia.Entidad.EstadoDeCompetencia;
import Persistencia.Entidad.EstadoDeFecha;
import Persistencia.Entidad.Fecha;
import Persistencia.Entidad.FormaDePuntuacion;
import Persistencia.Entidad.HistorialDeResultado;
import Persistencia.Entidad.LugarDeCompetencia;
import Persistencia.Entidad.Participante;
import Persistencia.Entidad.Partido;
import Persistencia.Entidad.Puntuacion;
import Persistencia.Entidad.ResultadoFinal;
import Persistencia.Entidad.Set;




public class ControlFixture {


	public ArrayList<DTOTablaDePosiciones> mostrarTablaDePosiciones(int idCompetencia) throws TablaNoPermitidaException

	{
		boolean habilitada;
		DAOCompetencia daoCompetencia = new DAOCompetencia();
		
		Competencia competencia = daoCompetencia.getCompetencia(idCompetencia);
		
		String nombreCompetencia = competencia.getNombre();
		
		if((competencia.getIdEstadoDeCompetencia() == EstadoDeCompetencia.FINALIZADA) || 
				(competencia.getIdEstadoDeCompetencia() == EstadoDeCompetencia.EN_DISPUTA))		
			habilitada = true;
		else
			habilitada = false;
		
		if (habilitada == true)
		{

			
			ArrayList<Partido> partidos;
			partidos = competencia.getListPartidos();
			

			
			boolean empatePermitido = true;
			if(competencia.getPuntosPorEmpate() == -1)
				empatePermitido = false;

			

			ArrayList<DTOTablaDePosiciones> listaDePosiciones = new ArrayList<DTOTablaDePosiciones>();

			int golesAFavor = 0;
			int golesEnContra;
			int partidosEmpatados;
			int partidosGanados;
			int partidosPerdidos;
			int puntosPorVictoria = competencia.getPuntosPorVictoria();
			int puntosPorEmpate = competencia.getPuntosPorEmpate();
			int puntosPorPresencia = competencia.getPuntosPorPresencia();
			int cantidadTantosAusencia = competencia.getPuntosPorAusencia();
			int cantidadPuntosPresencia;
			int idParticipante;
			
			for (int i = 0; i < competencia.getParticipantes().size(); i++ )
			{

				String nombreParticipante = competencia.getParticipantes().get(i).getNombre();
				idParticipante = competencia.getParticipantes().get(i).getId(); 
				if(competencia.esPuntuacion())
				{
					
					golesAFavor = 0;
					golesEnContra = 0;
					partidosGanados = 0;
					partidosPerdidos = 0;
					partidosEmpatados = 0;
					cantidadPuntosPresencia = 0;
					
					for(int j = 0; j < partidos.size(); j++)
					{
						if((idParticipante==partidos.get(j).getParticipante1().getId()) &&
								(partidos.get(j).existeResultado()))
						{
							
							if (partidos.get(j).getGolesAFavor(idParticipante) >= 0)
							{
								golesAFavor += partidos.get(j).getGolesAFavor(idParticipante);
								cantidadPuntosPresencia++;
							}
							else
								golesEnContra += cantidadTantosAusencia;
				
							if (partidos.get(j).getGolesEnContra(idParticipante) >= 0)
								golesEnContra += partidos.get(j).getGolesEnContra(idParticipante);
							else 
								golesAFavor += cantidadTantosAusencia;				
				
							if(partidos.get(j).getGolesAFavor(idParticipante) > 	
							   partidos.get(j).getGolesEnContra(idParticipante))	
								partidosGanados++;
							else if (partidos.get(j).getGolesAFavor(idParticipante) <
									partidos.get(j).getGolesEnContra(idParticipante))
								partidosPerdidos++;
							else if((empatePermitido) && 
									(partidos.get(j).getGolesAFavor(idParticipante) >= 0) &&
									(partidos.get(j).getGolesEnContra(idParticipante) >= 0))
								partidosEmpatados++;
						}
						else if ((idParticipante==partidos.get(j).getParticipante2().getId()) &&
								 (partidos.get(j).existeResultado()))
						{
							if (partidos.get(j).getGolesAFavor(idParticipante) >= 0)
							{
								golesAFavor += partidos.get(j).getGolesAFavor(idParticipante);
								cantidadPuntosPresencia++;
							}
							else 
								golesEnContra += cantidadTantosAusencia;	
							
							if (partidos.get(j).getGolesEnContra(idParticipante) >= 0)
								golesEnContra += partidos.get(j).getGolesEnContra(idParticipante);
							else 
								golesAFavor += cantidadTantosAusencia;				
							
							if(partidos.get(j).getGolesAFavor(idParticipante) > 	
							   partidos.get(j).getGolesEnContra(idParticipante))	
								partidosGanados++;
							else if (partidos.get(j).getGolesAFavor(idParticipante) <
									partidos.get(j).getGolesEnContra(idParticipante))
								partidosPerdidos++;
							else if((empatePermitido) && 
									(partidos.get(j).getGolesAFavor(idParticipante) >= 0) &&
									(partidos.get(j).getGolesEnContra(idParticipante) >= 0))
								partidosEmpatados++;
							
/*							if (partidos.get(j).getGolesAFavor(idParticipante)<0)
								partidosPerdidos++;
							else
							{
								golesAFavor += partidos.get(j).getGolesAFavor(idParticipante);
								if ( partidos.get(j).getGolesEnContra(idParticipante) >= 0)
								golesEnContra += partidos.get(j).getGolesEnContra(idParticipante);
							}
							if (partidos.get(j).getGolesAFavor(idParticipante) > 
								 partidos.get(j).getGolesEnContra(idParticipante))
									partidosGanados++;
							
							else if (partidos.get(j).getGolesAFavor(idParticipante) < 
							 		 partidos.get(j).getGolesEnContra(idParticipante))
									partidosPerdidos++;
							
							else if((empatePermitido)&& 
									(partidos.get(j).getGolesAFavor(idParticipante) >= 0) &&
									(partidos.get(j).getGolesEnContra(idParticipante) >= 0))
								partidosEmpatados++;
					*/	}
						 

						
						
					}
					
					DTOTablaDePosiciones dtoTablaDePosiciones = new DTOTablaDePosiciones (nombreCompetencia, nombreParticipante, golesAFavor,
								golesEnContra, ((puntosPorVictoria*partidosGanados) + (puntosPorEmpate * partidosEmpatados) + 
								(cantidadPuntosPresencia * puntosPorPresencia)), 
								partidosGanados, partidosPerdidos, partidosEmpatados);
					listaDePosiciones.add(dtoTablaDePosiciones);
				}
				else if(competencia.esSet())
				{
					partidosPerdidos = 0;
					partidosGanados = 0;
				
					for(int j = 0; j < partidos.size(); j++)
					{
						if(idParticipante==partidos.get(j).getParticipante1().getId())
						{					
							if(partidos.get(j).ganoPart1Set())
								partidosGanados++;
							else 
								partidosPerdidos++;

						}
						else if (idParticipante==partidos.get(j).getParticipante2().getId())
						{							
							if(!partidos.get(j).ganoPart1Set())
								partidosGanados++;
							else 
								partidosPerdidos++;

						}
					}
					
						DTOTablaDePosiciones dtoTablaDePosiciones = new DTOTablaDePosiciones (nombreCompetencia, nombreParticipante, 0,
								0, puntosPorVictoria*partidosGanados + puntosPorEmpate * 0, /*no se puede empatar*/
								partidosGanados, partidosPerdidos, 0);
						listaDePosiciones.add(dtoTablaDePosiciones);
				}
				else
				{
					partidosPerdidos = 0;
					partidosGanados = 0;
					partidosEmpatados=0;
				
					for(int j = 0; j < partidos.size(); j++)
					{
						 if(idParticipante==partidos.get(j).getParticipante1().getId())
						{
						 if(!(partidos.get(j).getResultadoFinal() == null))
						 {
							if(partidos.get(j).getResultadoFinal().getIdParticipanteGanador()==idParticipante)
								partidosGanados++;
							else if ((empatePermitido) &&(partidos.get(j).getResultadoFinal().getIdParticipanteGanador() == 0))
								partidosEmpatados++;
							else
								partidosPerdidos++;
						 }
						}
						else if(idParticipante==partidos.get(j).getParticipante2().getId())
						{			
						  if(!(partidos.get(j).getResultadoFinal() == null))
							 {
							if(partidos.get(j).getResultadoFinal().getIdParticipanteGanador()==idParticipante)
								partidosGanados++;
							else if ((empatePermitido) &&(partidos.get(j).getResultadoFinal().getIdParticipanteGanador() == 0))
								partidosEmpatados++;
							else
								partidosPerdidos++;
							}
						}
					}
						DTOTablaDePosiciones dtoTablaDePosiciones = new DTOTablaDePosiciones (nombreCompetencia, nombreParticipante, 0,
								0, puntosPorVictoria*partidosGanados + puntosPorEmpate * partidosEmpatados,
								partidosGanados, partidosPerdidos, partidosEmpatados);
						listaDePosiciones.add(dtoTablaDePosiciones);
				}
			}

		return listaDePosiciones;
	}
		else
			throw new TablaNoPermitidaException();
}

	public  void generarFixtureLiga(DTOFixture a) throws FixtureDisputaFinalizadoException, NoHayDisponibilidadException{
				
		int idCompetencia= a.getIdCompetencia();
		DAOCompetencia daoCompetencia=new DAOCompetencia();
		DAOPartido daoPartido=new DAOPartido();
		Competencia competencia= daoCompetencia.getCompetencia(idCompetencia);
				
		if(competencia.getEstadoDeCompetencia().getId()==3||competencia.getEstadoDeCompetencia().getId()==4){
			throw new FixtureDisputaFinalizadoException("Imposible crear el Fixture, la competencia esta en disputa o Finalizada.");
		}
		competencia.eliminarFechas();
				
		List<Participante> listaP= competencia.getParticipantes(); 
		int n = listaP.size();
		boolean disponibilidad= competencia.hayDisponibilidad(n);
		
		if(disponibilidad){
			if(n==2){
				
				EstadoDeFecha estado=daoPartido.getEstadoDeFecha(1);
				Fecha fecha= new Fecha(1,estado);				
				//Calcula el lugar de competencia para el partido
				List<Disponibilidad> disponibilidades=competencia.getDisponibilidades();
				int tamanio=disponibilidades.size();
				for(int counter=0;counter<tamanio;counter++){
					Disponibilidad disp=disponibilidades.get(counter);
					if(disp.getCantidadDePartidosDisponibles()>0){
						LugarDeCompetencia lugar=disp.getLugarDeCompetencia();
						disp.restar();
						Partido partido= new Partido(listaP.get(0),listaP.get(1),lugar);
						fecha.addPartido(partido);
						competencia.addFecha(fecha);
						counter=tamanio;
					}
				}
				//Fin
			}
			else{
				if((n%2) != 0){
					listaP.add(new Participante("nadie"));
					n=n+1;
				}
				
				//veces que rota la "matriz"
				for(int i=0;i<(n-1);i++){
					EstadoDeFecha estado=daoPartido.getEstadoDeFecha(1);
					Fecha fecha= new Fecha(i+1,estado);
					List<Disponibilidad> disponibilidades=competencia.getDisponibilidades();
					int b=0;
					int c=n-1;
					//agrega partidos
					
					//Crea una lista de lugares disponibles para usar
					int tamanio=disponibilidades.size();
					ArrayList<LugarDeCompetencia> lugar=new ArrayList<LugarDeCompetencia>();
					for(int t=0;t<tamanio;t++){
						int cantidad=disponibilidades.get(t).getCantidadDePartidosDisponibles();
							for(int q=0;q<cantidad;q++){
							lugar.add(disponibilidades.get(t).getLugarDeCompetencia());
						}
					}
					//Fin
					
					while(b<=c){
						if(!(listaP.get(b).getNombre().equals("nadie")) && (!listaP.get(c).getNombre().equals("nadie")))
						{	
							if(!lugar.isEmpty()){
							Partido partido=new Partido();
							partido= new Partido(listaP.get(b),listaP.get(c),lugar.get(0));
							fecha.addPartido(partido);
							lugar.remove(0);
							}
						}
						b++;
						c--;
						
					}
					competencia.addFecha(fecha);
					//rotar la "matriz"
					ArrayList<Participante> temporal = new ArrayList<Participante>();
					temporal.add(listaP.get(0));
					temporal.add(listaP.get(n-1));
					listaP.remove(n-1);
					listaP.remove(0);
					temporal.addAll(listaP);
					listaP.clear();
					listaP.addAll(temporal);
				}
			}
			EstadoDeCompetencia estadoDeCompetencia=daoCompetencia.getEstadoDeCompetencia(2);
			competencia.setEstadoDeCompetencia(estadoDeCompetencia);
			daoCompetencia.updateCompetencia(competencia);
		}
		else{
			throw new NoHayDisponibilidadException("No hay suficiente disponibilidad para llevar a cabo los encuentros.");
		}
	}

	public  void gestionarResultado(DTOGestionarResultado entrada) throws ResultadoNoModificableException, EmpateEnEliminacionException, 
																			FaltanPartidosAnterioresException, 
																			CompetenciaNoPermiteEmpateException, 
																			PuntajeNegativoException, EspaciosVaciosException, 
																			EmpateSetException, PuntajeOverflowException{
	//Creacion de las DAOs
	DAOCompetencia daoCompetencia=new DAOCompetencia();
	DAOPartido daoPartido= new DAOPartido();
	//Fin
	
	//Obtencion de Competencia y Partido
	Competencia competencia= daoCompetencia.getCompetencia(entrada.getIDCompetencia());
	Partido partido= daoPartido.getPartido(entrada.getIDPartido());
	Fecha fecha=daoPartido.getFecha(entrada.getIDFecha());
	//Fin
	
	//Validacion: Condiciones
	Boolean permiso= partido.permisoGestionResultado();
	Boolean modoEliminacion=competencia.esModoEliminacion();
	//Fin
	
	if(modoEliminacion==false || (modoEliminacion==true && permiso == true)){
		
		FormaDePuntuacion fPuntuacion=competencia.getFormaDePuntuacion();
		int tipo = fPuntuacion.getId();
		
		//Validacion: Entrada de datos
		ValidacionString.validarGestionDeResultado(partido,modoEliminacion,fPuntuacion,entrada,competencia);
		//Fin
		
		//Nota: se setea el puntaje a -1 en caso de ausencia
		if(tipo==FormaDePuntuacion.PUNTUACION){
			if(entrada.ausente1())
				entrada.setAusenteParticipante1();
			if(entrada.ausente2())
				entrada.setAusenteParticipante2();
		}
		//Fin

		Boolean editar= partido.existeResultado();
		
		//Tipo= (puntuacion/resultado final/sets)
		
		//Se edita/crea un resultado
		switch(tipo){
		
		case FormaDePuntuacion.PUNTUACION:
			if(editar==true){
				Puntuacion puntuacion=partido.getPuntuacion();
				HistorialDeResultado historial=new HistorialDeResultado(puntuacion);
				puntuacion.updatePuntuacion(entrada.getPuntajeEquipo1(),entrada.getPuntajeEquipo2(),historial);
				partido.updatePuntuacion(puntuacion);
			}
			else{
				Puntuacion puntuacion= new Puntuacion(entrada.getPuntajeEquipo1(),entrada.getPuntajeEquipo2(),partido.getParticipante1(),partido.getParticipante2());
				partido.addPuntuacion(puntuacion);
			}
		break;
		
		case FormaDePuntuacion.RESULTADO_FINAL:
			if(editar==true){
				ResultadoFinal resultadoF=partido.getResultadoFinal();
				HistorialDeResultado historial=new HistorialDeResultado(resultadoF);
				resultadoF.updateResultadoFinal(entrada.getResultadoFinal(),historial);
				partido.updateResultadoFinal(resultadoF);
			}
			else{
				ResultadoFinal resultadoF= new ResultadoFinal(entrada.getResultadoFinal(),partido.getParticipante1(),partido.getParticipante2());
				partido.addResultadoFinal(resultadoF);
			}
		break;
		
		case FormaDePuntuacion.SETS:
			if(editar==true){
				int cantidadDeSets=competencia.getCantidadDeSets();
				for(int i=0;i<cantidadDeSets;i++){
					Set set = partido.getSet(i);
					HistorialDeResultado historial=new HistorialDeResultado(set);
					set.setDatos(entrada.getSetJugador1().get(i),entrada.getSetJugador2().get(i), historial);
					partido.updateSet(set, i);
				}
			}
			else{
				for(int i=0;i<entrada.getSetJugador1().size();i++){
					Set set =new Set(entrada.getSetJugador1().get(i),entrada.getSetJugador2().get(i),i,partido.getParticipante1(),partido.getParticipante2());
					partido.addSet(set);
				}
			}
		break;
			
		}
			//Se updatea el partido
		fecha.updatePartido(partido);
			//Fin updatePartido
		
		//Fin de creacion/edicion resultado
		
		//Editar estado de fecha
		
			//Estado de fecha => 1=creada , 2=en disputa, 3=finalizada
		
		if(fecha.getEstadoDeFecha().getId()==1){
			//El estado de fecha esta creado, entonces no esta iniciada, la fecha pasa a estar En disputa
			EstadoDeFecha estado2= daoPartido.getEstadoDeFecha(2);
			fecha.setEstadoDeFecha(estado2);
		}
		if(fecha.completa()){
			//Los resultados de una fecha estan completos, la fecha pasa a estar Finalizada
			EstadoDeFecha estado3=daoPartido.getEstadoDeFecha(3);
			fecha.setEstadoDeFecha(estado3);
		}
		competencia.updateFecha(fecha);
		//Fin de Editar estado de Fecha
		
		//Editar Estado de Competencia
			//El estado de competencia se setea a En disputa (3)
		EstadoDeCompetencia estadoDeCompetencia=daoCompetencia.getEstadoDeCompetencia(3);
		competencia.setEstadoDeCompetencia(estadoDeCompetencia);
		Boolean esUltimoEncuentro=competencia.ultimoEncuentro();
		if(esUltimoEncuentro){
			//El estado de competencia se setea a Finalizada(4)
			EstadoDeCompetencia estadoFinal=daoCompetencia.getEstadoDeCompetencia(4);
			competencia.setEstadoDeCompetencia(estadoFinal);
		}
		daoCompetencia.updateCompetencia(competencia);
		//Fin Editar Competencia y se updatea
	}
	
}

	public  DTOMostrarFixture mostrarFixtureDeCompetencia(int idCompetencia){
		DTOMostrarFixture salida=new DTOMostrarFixture();
		DAOCompetencia daoCompetencia=new DAOCompetencia();
		Competencia competencia= daoCompetencia.getCompetencia(idCompetencia);

		
		List<Fecha> fechas= competencia.getFechas();
		
		int tipo=competencia.getFormaDePuntuacion().getId();
		
		DTOMostrarFixture auxiliar=new DTOMostrarFixture();

		
		
		for(int i=0;i<fechas.size();i++){
			DTOFecha fecha=new DTOFecha();
			fecha.setNumeroFecha(fechas.get(i).getNumero());
			fecha.setIdFecha(fechas.get(i).getId());
			List <Partido> partidos= fechas.get(i).getPartidos(); 
			
			for(int j=0;j<partidos.size();j++){
				DTOUnResultado unResultado=new DTOUnResultado();
				unResultado.setIdPartido(partidos.get(j).getId());
				unResultado.setParticipante1(partidos.get(j).getNombreParticipante1());
				unResultado.setParticipante2(partidos.get(j).getNombreParticipante2());

				switch(tipo){
				
				case FormaDePuntuacion.PUNTUACION:
					String cadenaResultado;
					if(partidos.get(j).getPuntuacion() != null)
					{
					cadenaResultado=(partidos.get(j).getPuntuacion().getPuntajeParticipante1().toString())+"-"+(partidos.get(j).getPuntuacion().getPuntajeParticipante2().toString());
					unResultado.setResultados(cadenaResultado);
					}
					break;
				
				case FormaDePuntuacion.RESULTADO_FINAL:
					String cadenaResultado2;
					
						if(partidos.get(j).existeResultado())
						{
							if(partidos.get(j).getResultadoFinal().getIdParticipanteGanador()!=0){
								cadenaResultado2=competencia.getNombreParticipante(partidos.get(j).getResultadoFinal().getIdParticipanteGanador());
								unResultado.setResultados(cadenaResultado2);
							}
							else
								unResultado.setResultados("empate");
						}
					break;
					
				case FormaDePuntuacion.SETS:
					String cadenaResultado3="";
					for(int k=0;k<partidos.get(j).getResultados().size();k++){
						Set set=partidos.get(j).getSet(k);
						cadenaResultado3=cadenaResultado3+"("+set.getPuntajeParticipante1()+"-"+set.getPuntajeParticipante2()+") ";
					}	
					unResultado.setResultados(cadenaResultado3);
					break;
				}
				
				fecha.addUnResultado(unResultado);
			}
			auxiliar.addFecha(fecha);
		}
		
		
		
		salida = ordenarDTOMostrarFixture(auxiliar);
		
		
		salida.setIdCompetencia(idCompetencia);
		salida.setNombreCompetencia(competencia.getNombre());
		salida.setEstadoDeCompetencia(competencia.getEstadoDeCompetencia().getNombre());
		
		
/*		for(int i = 0; i < salida.getFechas().size(); i++)
			System.out.println(salida.getFechas().get(i).getNumero()); */
		
		return salida;
	}

	

	private DTOMostrarFixture ordenarDTOMostrarFixture(DTOMostrarFixture salida) {

		DTOMostrarFixture auxiliar=new DTOMostrarFixture();

		for (int i = 1;i <= (salida.getFechas().size()); i++)
		{
			
			for (int j = 0; j < (salida.getFechas().size());j++)
			{
				if(salida.getFechas().get(j).getNumero() == i)
					auxiliar.addFecha(salida.getFechas().get(j));
			}
			
		}
		
		return auxiliar;
		
	}

	public void eliminarFixture(int idCompetencia) {
		
		
		//Se extrae una competencia
		DAOCompetencia daoCompetencia=new DAOCompetencia();
		Competencia competencia= daoCompetencia.getCompetencia(idCompetencia);
		//se elimina el fixture
		competencia.eliminarFechas();
		//se actualiza la competencia
		daoCompetencia.updateCompetencia(competencia);
		 

		}
	

	public DTOSets getDTOSets(int idPartido) {
		
		DAOPartido daoPartido=new DAOPartido();
		Partido partido=daoPartido.getPartido(idPartido);
		DTOSets dtoSets=new DTOSets();
		if(partido!=null){
		dtoSets.setParticipante1(partido.getNombreParticipante1());
		dtoSets.setParticipante2(partido.getNombreParticipante2());
		dtoSets.setEdicion(partido.existeResultado());
		
		if(partido.existeResultado()){		
			for(int i=0;i<partido.getResultados().size();i++){
				DTOSet dtoSet=new DTOSet();
				Set set= partido.getSet(i);
				dtoSet.setNumeroSet(set.getNumeroDeSet());
				dtoSet.setPuntaje1(set.getPuntajeParticipante1());
				dtoSet.setPuntaje2(set.getPuntajeParticipante2());
				dtoSets.addSet(dtoSet);
			}
		}
		}
		return dtoSets;
	}
	
	public DTOResultadoFinal getDTOResultadoFinal(int idPartido) {
		DAOPartido daoPartido = new DAOPartido();
		Partido partido = daoPartido.getPartido(idPartido);
		DTOResultadoFinal dtoResultadoFinal= new DTOResultadoFinal();
		
		dtoResultadoFinal.setParticipante1(partido.getNombreParticipante1());
		dtoResultadoFinal.setParticipante2(partido.getNombreParticipante2());
		dtoResultadoFinal.setIdParticipante1(partido.getParticipante1().getId());
		dtoResultadoFinal.setIdParticipante2(partido.getParticipante2().getId());
		dtoResultadoFinal.setEdicion(partido.existeResultado());
		
		if(partido.existeResultado()) {
			if (partido.getResultadoFinal().getIdParticipanteGanador()
					== partido.getParticipante1().getId()) {
				dtoResultadoFinal.setResultado(DTOResultadoFinal.GANO_PARTICIPANTE_1);
			}
			else if (partido.getResultadoFinal().getIdParticipanteGanador()
					== partido.getParticipante2().getId()) {
				dtoResultadoFinal.setResultado(DTOResultadoFinal.GANO_PARTICIPANTE_2);
			}
			else if (partido.getResultadoFinal().getIdParticipanteGanador() == 0) {
				dtoResultadoFinal.setResultado(DTOResultadoFinal.EMPATE);
			}
		}
		
		return dtoResultadoFinal;
	}
	
	public DTOPuntuacion getDTOPuntuacion(int idPartido) {
		DAOPartido daoPartido = new DAOPartido();
		Partido partido = daoPartido.getPartido(idPartido);
		DTOPuntuacion dtoPuntuacion = new DTOPuntuacion();
		
		dtoPuntuacion.setNombreParticipante1(partido.getNombreParticipante1());
		dtoPuntuacion.setNombreParticipante2(partido.getNombreParticipante2());
		dtoPuntuacion.setEdicion(partido.existeResultado());
		
		if(partido.existeResultado()) {
			dtoPuntuacion.setPuntaje1(partido.getPuntuacion().getPuntajeParticipante1());
			dtoPuntuacion.setPuntaje2(partido.getPuntuacion().getPuntajeParticipante2());
				
			if(dtoPuntuacion.getPuntaje1() == -1) {
				dtoPuntuacion.setAusente1(true);
			}
			else {
				dtoPuntuacion.setAusente1(false);
			}
			if(dtoPuntuacion.getPuntaje2() == -1){
				dtoPuntuacion.setAusente2(true);
			}
			else {
				dtoPuntuacion.setAusente2(false);
			}
		}
		
		return dtoPuntuacion;
	}

	
	//CODIGO NO NECESARIO, lo hice de onda, pero saltan errores
	public ArrayList<DTOProximosEncuentros> getProximosEncuentros(int idCompetencia) {
		DAOCompetencia daoCompetencia=new DAOCompetencia();
		Competencia competencia= daoCompetencia.getCompetencia(idCompetencia);
		List<Partido> partidos=competencia.getProximosPartidos();
		ArrayList<DTOProximosEncuentros> lista=new ArrayList<DTOProximosEncuentros>();
		
		for(int i=0;i<partidos.size();i++){
			DTOProximosEncuentros proximos=new DTOProximosEncuentros();
			proximos.setContrincante1(partidos.get(i).getNombreParticipante1());
			proximos.setContrincante1(partidos.get(i).getNombreParticipante1());
			proximos.setLugar(partidos.get(i).getLugarDeCompetencia().getNombre());
			lista.add(proximos);
		}
		
		return lista;
	}

	public int getCantidadSets(int idCompetencia) {
		DAOCompetencia daoCompetencia=new DAOCompetencia();
		return daoCompetencia.getCompetencia(idCompetencia).getCantidadDeSets();
	}
	
	
	//TODO
	public boolean permiteEmpate(int idCompetencia)
	{
		DAOCompetencia daocompetencia = new DAOCompetencia();
		Competencia competencia = new Competencia();
		
		competencia = daocompetencia.getCompetencia(idCompetencia);
		if(competencia.getPuntosPorEmpate() == -1)
			return false;
		else return true;
		
	}
}

